home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Cream of the Crop 20
/
Cream of the Crop 20 (Terry Blount) (1996).iso
/
os2
/
sysb091a.zip
/
sysbench
/
readme.hch
next >
Wrap
Text File
|
1994-11-05
|
21KB
|
560 lines
Prelude for those that don't read the documentation:
Do not mail me bug reports. I can't fix them... Other opinions on the
program are welcome.
I do not know if this program works on a CPU without math co-proc (like the
486-SX)
System Benchmark "SysBench" 0.9.0
---------------------------------
(C) 1994 Henrik Harmsen
The disk IO code: (C) 1994 Kai Uwe Rommel
Contents:
1 Introduction
2 Tests
3 Copyright notice
4 Thanks
Appendix A : Todo
Appendix B : Building
Appendix C : Example results
---
1 Introduction
I thought OS/2 needed a benchmark program, so I wrote one. This
program is not quite finished, and probably never will be, not by me
anyway, since I'm saying goodbye to OS/2 and turning my attention to
Linux. The reasons for this has not so much to do with OS/2, which is
still a great OS, as it has to do with Linux. Linux is slick,
super-fast, finally has drivers for my Viper card, has free TCP/IP and
last but not least, Linux is Unix.
This means I am probably not going to make updates to this program,
since I won't have OS/2 on my disk anymore. I'm saying probably, since
I can't read the future. Maybe one day my whimsical mind will think
OS/2 is more fun that Linux, who knows ? :-)
It also means that I am donating this program to anyone who is willing
to continue working on it. If you think you want to continue working
on this program, make sure you clearly note that this is released by
you, not me. To do this, change the version number to 0.9.0xxx, where
xxx are your initials. For example 0.9.0hch, which would indicate that
I (Henrik C Harmsen) has made this release. The version numbering
scheme should follow that of GCC. The first number is the major
release number, to be increased when major enhancements have been made
to the program or it is considered out of beta. The second number is
the minor release number, increase it when you have made small changes
to the program. The last number should be increased when making
bug-fixes only.
Take a look at the appendices for more information on what needs to be
done, what's not quite finished yet, and how to re-build the
program. Among other things, this document needs rewriting.
Do not send me complaints about bugs and errors, since I will have no
way of fixing them...
Now, that said, let's take a look at what this program tests.
2 Tests
HANDLE WITH CARE! DO NOT BLINDLY TRUST BENCHMARK VALUES. THEY ARE ONLY
GOOD IF YOU KNOW WHAT THEY ARE TESTING AND KNOW WHAT THEY ARE NOT
TESTING...
The values obtained here are not useful for comparing against values
obtained from other benchmarks programs. Even though one of the tests
for example measure Linpack performance and yields a value in MFLOPS,
this value is not useful in comparing with other values from a
different benchmark program. The only exception here is the dhrystone
2.1 value which might possibly be compared to values from other
dhrystone 2.1 benchmarks. As a rule: Only compare values with people
running this same benchmark program.
Almost all tests are adaptive in that they will first measure the
approximate speed of your computer so the test will take about 10-15
seconds in total, no matter how slow or fast your computer is. The
ones that are not adaptive are the floating point tests and the
CPU integer tests with the exception of the dhrystone test.
2.1 Graphic tests
These tests test how fast the video hardware/display driver
combination can pump pixels to the screen. OS/2 has long had abysmal
display drivers for many cards, these tests are meant to sort out
whether they really are bad, good or stink.
Most window operations are using only a few key operations of the
video card accelerator. Take a look at your windows, they're mostly
built from filled rectangles, with some text and vertical and
horizontal lines. Maybe a few bitmaps here and there (icons and such).
The PM-marks are calculated from the other values as a weighted
arithmetic mean-value.
2.1.1 BitBlit S->S Copy
Tests the speed of the bitblit screen->screen copy operation. One of
the most important values, since it affects how fast you can scroll
text, and move large windows.
2.1.2 BitBlit M->S Copy
Tests the speed of the bitblit memory->screen copy operation. This
affects how fast updates of large bitmaps are and all operations that
copy data from RAM to Video RAM.
2.1.3 Filled rectangle, patterned filled rectangle.
Tests how fast the blitter can blank areas with a color or stipple
pattern. When updating a window, the background is usually blanked
with a single color or pattern before text or other things are drawn
on it.
2.1.4 Lines
Tests the speed of line-drawing in different directions. The
horizontal and vertical line drawing speed is important when drawing
frames around windows and such.
2.1.5 Text render
Extremely important function for speedy updates in text editors, shell
windows, word processors etc.
2.2 CPU Integer tests
The CPU tests are divided into two sections, one to test 'integer'
performance, meaning not only integer arithmetics but also every other
'normal' program that does some kind of data processing. 99% of all
applications do not use floating-point arithmetic. Those that do are
usually ray-tracers, scientific engineering type of programs etc.
The CPU-int marks are calculated as a weighted mean average of the other
tests.
2.2.1 Dhrystone VAX MIPS
When reading about how many MIPS a computer performs, that is usually
tested by running this Dhrystone test and adjusting the result to be
relative to one VAX 11/780 MIPS. That means, this test does not
benchmark the number of million instructions per second (MIPS) as
defined by machine instructions, but rather a weighted value against
the base reference of one VAX 11/780 MIPS.
This test uses very little memory, meaning it will measure the CPU
performance only, not taking into account other vital parts as memory
speed etc.
Here is an excerpt from the sources from where I got this program:
"Dhrystone is a short synthetic benchmark program intended to be
representative for system (integer) programming. Based on published
statistics on use of programming language features: see original
publication in CACM 27,10 (Oct 1984). Orginally published in ADA, now
mostly used in C. Version 2 (in C) published in SIGPLAN Notices 23,8
(Aug 1988), together with measurement rules. Version 1 is no longer
recommended since state-of-the-art compilers can eliminate too much
'dead code' from the benchmark (However, quoted MIPS numbers are often
based on version 1). Problems: Due to its small size (100 HLL
statements, 1-1.5 KB code), the memory system outside the cache is not
tested; compilers can too easily optimize for Dhrystone; string
operations are somewhat over-represented. Recommendation: Use it for
controlled experiments only; don't blindly trust single Dhrystone MIPS
numbers quoted somewhere (don't do this for any benchmark)."
This test is based on the C-version of Dhrystone 2.1.
2.2.2 Hanoi
An integer program which solves the Towers of Hanoi puzzle using
recursive function calls. It uses very little memory, and thus does
not test memory speed.
2.2.3 Heapsort
Tests how fast your computer can sort a large array of random values
using the heapsort algorithm. Tests both CPU and memory speed. The
MIPS are just a measurement against some arbitrary base MIPS
reference. This test uses about 1 MB memory.
2.2.4 Sieve
Tests how fast your computer can find lots of prime numbers using the
sieve of Eratosthenes using arrays from 8 kB to 1.2 MB. The result is
a weighted mean value of the different speeds. Tests both CPU and
memory speed.
2.3 CPU floating point tests
These tests measure how fast your computer is at floating point
arithmetics. (Floating point means non-integer numbers like 2.3,
0.24 etc.)
The CPUfloat-marks are calculated as a weighted mean average of the
other values.
2.3.1 Linpack
This is the Linpack program (floating-point) converted to C. Results
here are sensitive to cache effects and memory speed. This version
tests only the rolled double precision version.
2.3.2 Flops
Estimates MFLOPS rating for specific FADD, FSU